const program = require('commander');
const majo = require('majo');
const fs = require('fs');
const path = require('path');
const chalk = require('chalk');

const unified = require('unified');
const parse = require('remark-parse');
const stringify = require('remark-stringify');

const yamlConfig = require('remark-yaml-config');
const frontmatter = require('remark-frontmatter');

let fileAPIs = {};
const remarkWithYaml = unified()
    .use(parse)
    .use(stringify, {
        paddedTable: false,
        listItemIndent: 1,
        stringLength: () => 3,
    })
    .use(frontmatter)
    .use(yamlConfig);

const stream = majo.majo();

function getCellValue(node) {
    return node.children[0].children[0].value;
}

// from small to large
const sizeBreakPoints = ['xs', 'sm', 'md', 'lg', 'xl', 'xxl'];

const whiteMethodList = ['afterChange', 'beforeChange'];

const groups = {
    isDynamic: (val) =>
        /^on[A-Z]/.test(val) || whiteMethodList.indexOf(val) > -1,
    isSize: (val) => sizeBreakPoints.indexOf(val) > -1,
};

function asciiSort(prev, next) {
    if (prev > next) {
        return 1;
    }

    if (prev < next) {
        return -1;
    }

    return 0;
}

// follow the alphabet order
function alphabetSort(nodes) {
    // use toLowerCase to keep `case insensitive`
    return nodes.sort((...comparison) =>
        asciiSort(...comparison.map((val) => getCellValue(val).toLowerCase())),
    );
}

function sizeSort(nodes) {
    return nodes.sort((...comparison) =>
        asciiSort(
            ...comparison.map((val) =>
                sizeBreakPoints.indexOf(getCellValue(val).toLowerCase()),
            ),
        ),
    );
}

function sort(ast, filename) {
    const nameMatch = filename.match(/^components\/([^/]*)\//);
    const componentName = nameMatch[1];
    fileAPIs[componentName] = fileAPIs[componentName] || {
        static: new Set(),
        size: new Set(),
        dynamic: new Set(),
    };

    ast.children.forEach((child) => {
        const staticProps = [];
        // prefix with `on`
        const dynamicProps = [];
        // one of ['xs', 'sm', 'md', 'lg', 'xl']
        const sizeProps = [];

        // find table markdown type
        if (child.type === 'table') {
            // slice will create new array, so sort can affect the original array.
            // slice(1) cut down the thead
            child.children.slice(1).forEach((node) => {
                const value = getCellValue(node);
                if (groups.isDynamic(value)) {
                    dynamicProps.push(node);
                    fileAPIs[componentName].dynamic.add(value);
                } else if (groups.isSize(value)) {
                    sizeProps.push(node);
                    fileAPIs[componentName].size.add(value);
                } else {
                    staticProps.push(node);
                    fileAPIs[componentName].static.add(value);
                }
            });

            // eslint-disable-next-line
            child.children = [
                child.children[0],
                ...alphabetSort(staticProps),
                ...sizeSort(sizeProps),
                ...alphabetSort(dynamicProps),
            ];
        }
    });

    return ast;
}

function sortAPI(md, filename) {
    return remarkWithYaml.stringify(sort(remarkWithYaml.parse(md), filename));
}

function sortMiddleware(ctx) {
    Object.keys(ctx.files).forEach((filename) => {
        const content = ctx.fileContents(filename);
        ctx.writeContents(filename, sortAPI(content, filename));
    });
}

module.exports = () => {
    fileAPIs = {};

    program
        .version('0.1.0')
        .option(
            '-f, --file [file]',
            'Specify which file to be transformed',
            // default value
            'components/**/index.+(zh-CN|en-US).md',
        )
        .option(
            '-o, --output [output]',
            'Specify component api output path',
            '~component-api.json',
        )
        .parse(process.argv);
    // Get the markdown file all need to be transformed

    /* eslint-disable no-console */
    stream
        .source(program.file)
        .use(sortMiddleware)
        .dest('.')
        .then(() => {
            if (program.output) {
                const data = {};
                Object.keys(fileAPIs).forEach((componentName) => {
                    data[componentName] = {
                        static: [...fileAPIs[componentName].static],
                        size: [...fileAPIs[componentName].size],
                        dynamic: [...fileAPIs[componentName].dynamic],
                    };
                });

                const reportPath = path.resolve(program.output);
                fs.writeFileSync(
                    reportPath,
                    JSON.stringify(data, null, 2),
                    'utf8',
                );
                console.log(chalk.cyan(`API list file: ${reportPath}`));
            }
        })
        .then(() => {
            console.log(chalk.green(`sort ant-design-vue api successfully!`));
        });
    /* eslint-enable no-console */
};
